import { computed, onMounted, onUnmounted, ref, watch } from 'vue';

import { useAccessStore } from '@vben/stores';
import type { AuthApi } from '#/api/core/auth';
import { useAuthStore } from '#/store/auth';
import { tokenManager } from '#/utils/token-manager';


/**
 * 自动化Token管理Hook
 * 提供完全自动的Token续期功能，支持动态配置
 */
export function useAutoTokenManager() {
  const accessStore = useAccessStore();
  const authStore = useAuthStore();

  const tokenInfo = ref<AuthApi.TokenStatusResult | null>(null);
  const loading = ref(false);
  const autoRefreshEnabled = ref(false); // 默认关闭，从配置中加载

  // 动态配置参数
  const tokenExpiryMinutes = ref(30); // Token过期时间（分钟）
  const renewalThresholdMinutes = ref(10); // 续期阈值（分钟）

  // 是否有有效的token
  const hasValidToken = computed(() => {
    return !!accessStore.accessToken && tokenInfo.value?.valid;
  });

  // Token是否即将过期（根据配置的续期阈值判断）
  const isTokenExpiringSoon = computed(() => {
    if (!tokenInfo.value) return false;
    // 使用配置的续期阈值的一半作为"即将过期"的判断标准
    const criticalThreshold = Math.min(renewalThresholdMinutes.value / 2, 5) * 60 * 1000;
    return tokenInfo.value.remainingTimeMs < criticalThreshold;
  });

  // Token是否需要续期（根据配置的续期阈值判断）
  const needsAutoRefresh = computed(() => {
    if (!tokenInfo.value || !autoRefreshEnabled.value) return false;
    const thresholdMs = renewalThresholdMinutes.value * 60 * 1000;
    return tokenInfo.value.needsRefresh || tokenInfo.value.remainingTimeMs < thresholdMs;
  });

  // 剩余时间文本
  const remainingTimeText = computed(() => {
    return tokenInfo.value?.remainingTimeText || '未知';
  });

  // Token状态文本
  const statusText = computed(() => {
    if (!tokenInfo.value) return 'Token未知';

    if (!tokenInfo.value.valid) return 'Token无效';

    if (isTokenExpiringSoon.value) return 'Token即将过期';

    if (needsAutoRefresh.value) return 'Token需要续期';

    return 'Token正常';
  });

  // 状态颜色
  const statusColor = computed(() => {
    if (!tokenInfo.value || !tokenInfo.value.valid) return 'error';

    if (isTokenExpiringSoon.value) return 'error';

    if (needsAutoRefresh.value) return 'warning';

    return 'success';
  });

  /**
   * 加载JWT配置
   */
  const loadJwtConfig = async () => {
    try {
      const { getJwtConfigApi } = await import('#/api/core/sysconfig');
      const config = await getJwtConfigApi();

      tokenExpiryMinutes.value = config.tokenExpiry;
      renewalThresholdMinutes.value = config.renewalThreshold;
      autoRefreshEnabled.value = config.autoRefresh;

      console.log('JWT配置已加载:', {
        tokenExpiry: config.tokenExpiry,
        renewalThreshold: config.renewalThreshold,
        autoRefresh: config.autoRefresh
      });

      // 🔥 同步更新TokenManager配置，但不立即获取状态
      tokenManager.updateJwtConfig({
        renewalThreshold: config.renewalThreshold,
        autoRefresh: config.autoRefresh
      });

      // 🔥 移除立即调用getTokenStatus，减少频繁请求
    } catch (error) {
      console.warn('加载JWT配置失败，使用默认值:', error);
    }
  };

  /**
   * 获取Token状态
   */
  const getTokenStatus = async () => {
    if (!accessStore?.accessToken) {
      tokenInfo.value = null;
      return null;
    }

    try {
      loading.value = true;
      const result = await authStore.getTokenInfo();
      tokenInfo.value = result;

      // 🔥 移除自动续期逻辑，避免循环调用
      // TokenManager已经负责自动续期，这里只负责获取状态用于UI显示

      return result;
    } catch (err) {
      console.error('获取Token状态失败:', err);
      tokenInfo.value = null;
      return null;
    } finally {
      loading.value = false;
    }
  };

  /**
   * 智能检查并自动续期（已由TokenManager接管，这里保留用于手动触发）
   */
  const checkAndAutoRefresh = async () => {
    if (!tokenInfo.value || !autoRefreshEnabled.value) return;

    // 🔥 现在由TokenManager的定时任务负责自动续期，这里只是更新UI状态
    console.log('🔄 手动检查Token状态...');

    try {
      await getTokenStatus();
    } catch (error) {
      console.error('手动检查Token状态失败:', error);
    }
  };

  /**
   * 启动智能续期监控（已由TokenManager的定时任务接管，这里不再启动定时任务）
   */
  const startAutoRefreshMonitoring = () => {
    // 🔥 移除重复的定时任务，避免冲突
    // TokenManager已经负责自动续期，这里只需要初始化UI状态
    console.log('🚀 Token状态监控已启动（由TokenManager统一管理）');
  };

  /**
   * 停止自动续期监控
   */
  const stopAutoRefreshMonitoring = () => {
    // 🔥 不再管理定时任务，由TokenManager统一管理
    console.log('⏹️ Token状态监控已停止（由TokenManager统一管理）');
  };

  /**
   * 手动触发续期（作为备用方案）
   */
  const manualRefresh = async () => {
    try {
      loading.value = true;
      const success = await authStore.refreshToken();
      if (success) {
        await getTokenStatus();
        console.log('手动续期成功');
      } else {
        console.warn('手动续期失败');
      }
      return success;
    } catch (err) {
      console.error('手动续期失败:', err);
      return false;
    } finally {
      loading.value = false;
    }
  };

    /**
   * 启用/禁用自动续期
   */
  const toggleAutoRefresh = (enabled: boolean) => {
    autoRefreshEnabled.value = enabled;

    // 🔥 同步更新TokenManager的自动续期状态
    tokenManager.updateJwtConfig({
      autoRefresh: enabled,
      renewalThreshold: renewalThresholdMinutes.value
    });

    // 🔥 移除立即调用getTokenStatus，减少频繁请求
    console.log(`自动续期已${enabled ? '开启' : '关闭'}`);
  };

    /**
   * 更新JWT配置（在保存配置后调用）
   */
  const updateJwtConfig = (config: { tokenExpiry: number; renewalThreshold: number; autoRefresh: boolean }) => {
    tokenExpiryMinutes.value = config.tokenExpiry;
    renewalThresholdMinutes.value = config.renewalThreshold;

    console.log('JWT配置已更新:', {
      tokenExpiry: config.tokenExpiry,
      renewalThreshold: config.renewalThreshold,
      autoRefresh: config.autoRefresh
    });

    // 更新自动续期状态
    toggleAutoRefresh(config.autoRefresh);

    // 同步更新TokenManager的配置
    tokenManager.updateJwtConfig({
      autoRefresh: config.autoRefresh,
      renewalThreshold: config.renewalThreshold
    });
  };

  /**
   * 强制更新Token状态（用于自动续期关闭时感知Token变化）
   */
  const forceUpdateTokenStatus = async () => {
    if (!accessStore?.accessToken) {
      tokenInfo.value = null;
      return null;
    }

    try {
      const result = await authStore.getTokenInfo();
      tokenInfo.value = result;
      console.log('Token状态已强制更新');
      return result;
    } catch (err) {
      console.error('强制更新Token状态失败:', err);
      tokenInfo.value = null;
      return null;
    }
  };

  // 监听accessToken变化
  watch(
    () => accessStore.accessToken,
    (newToken) => {
      if (newToken) {
        if (autoRefreshEnabled.value) {
          // 🔥 自动续期开启时的逻辑
          console.log('Token已更新，TokenManager将自动处理续期');
        } else {
          // 🔥 自动续期关闭时，仍然要感知Token变化（通过X-New-Token头更新）
          console.log('Token已更新（自动续期关闭，但仍处理响应头中的新Token）');
          // 可以选择性地更新UI状态，但不启动定时任务
          if (tokenInfo.value) {
            // 如果当前有Token信息，可以清空让UI重新获取
            tokenInfo.value = null;
          }
        }
      } else {
        // 没有Token时清空状态
        tokenInfo.value = null;
        console.log('Token已清空');
      }
    },
    { immediate: true }
  );

  // 组件挂载时启动
  onMounted(async () => {
    // 先加载配置
    await loadJwtConfig();

    // 🔥 移除立即调用getTokenStatus，减少频繁请求
    // 只在用户主动点击时才获取状态
    console.log('自动Token管理器已初始化');
  });

  // 组件卸载时清理
  onUnmounted(() => {
    // 🔥 不再需要清理定时任务，由TokenManager统一管理
  });

  return {
    // 状态
    tokenInfo,
    loading,
    hasValidToken,
    isTokenExpiringSoon,
    needsAutoRefresh,
    remainingTimeText,
    statusText,
    statusColor,
    autoRefreshEnabled,
    tokenExpiryMinutes,
    renewalThresholdMinutes,

    // 方法
    getTokenStatus,
    manualRefresh,
    toggleAutoRefresh,
    startAutoRefreshMonitoring,
    stopAutoRefreshMonitoring,
    loadJwtConfig,
    updateJwtConfig,
    forceUpdateTokenStatus,
  };
}
